using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
using SeataNet.Core.Attributes;
using SeataNet.Core.Common;
using SeataNet.Core.Context;
using SeataNet.Core.Exceptions;
using SeataNet.Core.Model;
using SeataNet.Core.Transaction;
using System.Collections.Concurrent;
using System.Reflection;
using System.Text.Json;

namespace SeataNet.Core.TCC
{
    /// <summary>
    /// TCC事务管理器接口
    ///
    /// 定义TCC（Try-Confirm-Cancel）模式分布式事务的核心管理接口。
    ///
    /// 职责：
    /// 1. 管理TCC全局事务的生命周期（开始、提交、回滚）
    /// 2. 注册和管理TCC分支事务
    /// 3. 协调Try、Confirm、Cancel三个阶段的执行
    /// 4. 维护TCC事务上下文和分支状态
    /// 5. 与TC通信，同步事务状态
    ///
    /// TCC模式原理：
    /// ```
    /// TCC模式将分布式事务分为三个阶段：
    ///
    /// 1. Try阶段（一阶段）：
    ///    - 尝试执行业务操作
    ///    - 预留业务资源（如冻结账户余额）
    ///    - 检查业务规则和约束
    ///    - Try成功后资源被锁定，但未提交
    ///
    /// 2. Confirm阶段（二阶段 - 成功路径）：
    ///    - Try成功后，TC发起Confirm
    ///    - 确认提交业务操作
    ///    - 使用Try阶段预留的资源
    ///    - 释放业务资源锁定
    ///
    /// 3. Cancel阶段（二阶段 - 失败路径）：
    ///    - Try失败或业务异常时，TC发起Cancel
    ///    - 取消业务操作
    ///    - 释放Try阶段预留的资源
    ///    - 回滚到Try之前的状态
    /// ```
    ///
    /// 与AT模式的区别：
    /// - AT模式：自动生成undo_log，对业务无侵入
    /// - TCC模式：需要实现Try/Confirm/Cancel三个方法，对业务有侵入
    /// - AT模式：适合简单CRUD操作
    /// - TCC模式：适合复杂业务逻辑，性能更高
    ///
    /// 实现类：
    /// - DefaultTccTransactionManager：默认实现，管理TCC事务的完整生命周期
    ///
    /// 使用场景：
    /// - 需要精细控制事务逻辑的场景
    /// - 对性能要求较高的场景（无undo_log）
    /// - 业务逻辑复杂，无法用undo_log回滚的场景
    /// - 需要资源预留和释放的场景（如库存扣减）
    ///
    /// 注意事项：
    /// - TCC模式需要实现Try/Confirm/Cancel三个方法
    /// - Confirm和Cancel必须是幂等的（可重复执行）
    /// - Try阶段应该预留资源，而不是直接修改
    /// - Cancel阶段应该释放Try预留的资源
    /// </summary>
    public interface ITccTransactionManager
    {
        /// <summary>
        /// 开始TCC事务
        ///
        /// 开启新的TCC全局事务，创建事务上下文并分配XID。
        ///
        /// 执行流程：
        /// 1. 调用ITransactionManager.BeginAsync()开启底层全局事务
        /// 2. TC分配全局事务ID（XID）
        /// 3. 创建TccTransactionContext事务上下文
        /// 4. 设置事务状态为Trying，阶段为Try
        /// 5. 将上下文添加到_transactionContexts缓存
        /// 6. 返回BeginResult包含XID
        ///
        /// 调用时机：
        /// - 应用开始TCC分布式事务时
        /// - 通常由TccTransactionInterceptor自动调用
        /// - 或使用TccTransactionTemplate手动调用
        ///
        /// 注意事项：
        /// - timeoutMs默认60秒，超时TC会自动回滚
        /// - name用于日志和监控标识
        /// - 开启失败会抛出TransactionException
        /// </summary>
        /// <param name="timeoutMs">超时时间（毫秒），默认60000ms</param>
        /// <param name="name">事务名称，用于日志和监控</param>
        /// <returns>事务开始结果，包含Success标志和XID</returns>
        Task<BeginResult> BeginAsync(int timeoutMs = 60000, string? name = null);

        /// <summary>
        /// 提交TCC事务
        ///
        /// 提交全局事务，执行所有分支的Confirm阶段。
        ///
        /// 执行流程：
        /// 1. 获取TccTransactionContext事务上下文
        /// 2. 设置状态为Confirming，阶段为Confirm
        /// 3. 遍历所有分支，依次执行ExecuteConfirmAsync()
        /// 4. ExecuteConfirmAsync()调用业务的Confirm方法
        /// 5. 检查是否所有分支都Confirm成功
        /// 6. 调用ITransactionManager.CommitAsync()提交底层事务
        /// 7. 清理事务上下文
        ///
        /// Confirm阶段说明：
        /// - Confirm确认提交Try阶段预留的资源
        /// - Confirm必须是幂等的（TC可能重试）
        /// - Confirm失败会记录日志，但不抛出异常
        ///
        /// 注意事项：
        /// - 如果部分分支Confirm失败，整体仍可能返回成功
        /// - TC会异步重试失败的Confirm
        /// - Confirm方法应该快速执行（不应有耗时操作）
        /// </summary>
        /// <param name="xid">全局事务ID</param>
        /// <returns>事务提交结果，包含Success标志和Message</returns>
        Task<CommitResult> CommitAsync(string xid);

        /// <summary>
        /// 回滚TCC事务
        ///
        /// 回滚全局事务，执行所有分支的Cancel阶段。
        ///
        /// 执行流程：
        /// 1. 获取TccTransactionContext事务上下文
        /// 2. 设置状态为Canceling，阶段为Cancel
        /// 3. 遍历所有分支，依次执行ExecuteCancelAsync()
        /// 4. ExecuteCancelAsync()调用业务的Cancel方法
        /// 5. 检查是否所有分支都Cancel成功
        /// 6. 调用ITransactionManager.RollbackAsync()回滚底层事务
        /// 7. 清理事务上下文
        ///
        /// Cancel阶段说明：
        /// - Cancel释放Try阶段预留的资源
        /// - Cancel必须是幂等的（TC可能重试）
        /// - Cancel失败会记录日志，但不抛出异常
        ///
        /// 调用时机：
        /// - Try阶段发生异常时
        /// - 全局事务需要回滚时
        /// - TC超时自动回滚时
        ///
        /// 注意事项：
        /// - 如果部分分支Cancel失败，整体仍可能返回成功
        /// - TC会异步重试失败的Cancel
        /// - Cancel方法应该快速执行
        /// </summary>
        /// <param name="xid">全局事务ID</param>
        /// <returns>事务回滚结果，包含Success标志和Message</returns>
        Task<RollbackResult> RollbackAsync(string xid);

        /// <summary>
        /// 注册TCC分支事务
        ///
        /// 向TC注册新的TCC分支事务，并添加到事务上下文。
        ///
        /// 执行流程：
        /// 1. 获取TccTransactionContext事务上下文
        /// 2. 创建BranchRegisterRequest请求
        /// 3. 调用ITransactionManager.RegisterBranchAsync()向TC注册
        /// 4. TC分配BranchId并返回
        /// 5. 创建TccBranchContext分支上下文
        /// 6. 将分支上下文添加到全局事务的Branches列表
        /// 7. 返回BranchRegisterResponse包含BranchId
        ///
        /// actionContext说明：
        /// - JSON格式的TccActionContext对象
        /// - 包含ServiceName、MethodName、Parameters等
        /// - Confirm和Cancel阶段会使用此上下文
        ///
        /// 调用时机：
        /// - Try阶段执行前
        /// - TccServiceProxy自动调用
        ///
        /// 注意事项：
        /// - 注册失败会抛出TransactionException
        /// - actionContext用于Confirm/Cancel阶段定位服务
        /// - resourceId通常是服务名称
        /// </summary>
        /// <param name="xid">全局事务ID</param>
        /// <param name="resourceId">资源ID，通常是TCC服务名称</param>
        /// <param name="actionContext">动作上下文，JSON格式的TccActionContext</param>
        /// <returns>分支注册结果，包含BranchId和ResultCode</returns>
        Task<BranchRegisterResponse> RegisterBranchAsync(string xid, string resourceId, string actionContext);

        /// <summary>
        /// 注册TCC分支事务（简化版本）
        ///
        /// RegisterBranchAsync的简化版本，直接返回BranchId而非完整响应对象。
        ///
        /// 执行流程：
        /// 1. 调用RegisterBranchAsync(xid, resourceId, actionContext)
        /// 2. 提取响应中的BranchId
        /// 3. 直接返回BranchId（失败返回0）
        ///
        /// 使用场景：
        /// - 只需要BranchId，不关心完整响应时
        /// - 简化业务代码调用
        ///
        /// 注意事项：
        /// - 注册失败返回0而非抛出异常
        /// - 建议使用RegisterBranchAsync获取完整结果
        /// </summary>
        /// <param name="xid">全局事务ID</param>
        /// <param name="resourceId">资源ID</param>
        /// <param name="actionContext">动作上下文</param>
        /// <returns>分支事务ID，失败返回0</returns>
        Task<long> BranchRegisterAsync(string xid, string resourceId, string actionContext);

        /// <summary>
        /// 上报TCC分支事务状态
        ///
        /// 向TC上报分支事务的执行状态。
        ///
        /// 执行流程：
        /// 1. 创建BranchReportRequest请求
        /// 2. 设置BranchType为TCC类型
        /// 3. 调用ITransactionManager.ReportBranchStatusAsync()
        /// 4. TC更新分支状态
        /// 5. 返回BranchReportResponse
        ///
        /// 状态说明：
        /// - PhaseOneDone：Try阶段完成
        /// - PhaseTwoCommitted：Confirm阶段完成
        /// - PhaseTwoRollbacked：Cancel阶段完成
        /// - PhaseTwoCommitFailedRetryable：Confirm失败，可重试
        /// - PhaseTwoRollbackFailedRetryable：Cancel失败，可重试
        ///
        /// 调用时机：
        /// - Try阶段完成后
        /// - Confirm阶段完成后
        /// - Cancel阶段完成后
        ///
        /// 注意事项：
        /// - 上报失败会抛出TransactionException
        /// - TC根据状态决定后续操作
        /// </summary>
        /// <param name="xid">全局事务ID</param>
        /// <param name="branchId">分支事务ID</param>
        /// <param name="status">分支状态</param>
        /// <returns>状态上报结果</returns>
        Task<BranchReportResponse> ReportBranchStatusAsync(string xid, long branchId, BranchStatus status);

        /// <summary>
        /// 上报TCC分支事务状态（简化版本）
        ///
        /// ReportBranchStatusAsync的简化版本，使用TccBranchStatus而非BranchStatus。
        ///
        /// 执行流程：
        /// 1. 将TccBranchStatus映射为BranchStatus
        /// 2. 调用ReportBranchStatusAsync(xid, branchId, branchStatus)
        /// 3. 检查ResultCode是否为Success
        /// 4. 返回布尔值
        ///
        /// 状态映射：
        /// - Registered → Registered
        /// - Trying → PhaseOneDone
        /// - Confirmed → PhaseTwoCommitted
        /// - Canceled → PhaseTwoRollbacked
        /// - ConfirmFailed → PhaseTwoCommitFailedRetryable
        /// - CancelFailed → PhaseTwoRollbackFailedRetryable
        ///
        /// 注意事项：
        /// - 上报失败返回false而非抛出异常
        /// - 使用TCC特定的状态枚举
        /// </summary>
        /// <param name="xid">全局事务ID</param>
        /// <param name="branchId">分支事务ID</param>
        /// <param name="status">TCC分支状态</param>
        /// <returns>上报成功返回true，失败返回false</returns>
        Task<bool> BranchReportAsync(string xid, long branchId, TccBranchStatus status);

        /// <summary>
        /// 获取TCC分支事务状态
        ///
        /// 从TC查询分支事务的当前状态。
        ///
        /// 执行流程：
        /// 1. 创建BranchStatusRequest请求
        /// 2. 设置BranchType为TCC类型
        /// 3. 调用ITransactionManager.GetBranchStatusAsync()
        /// 4. TC返回分支当前状态
        ///
        /// 使用场景：
        /// - 监控分支事务状态
        /// - 诊断事务执行情况
        /// - 重试前检查状态
        ///
        /// 注意事项：
        /// - 查询失败返回BranchStatus.Unknown
        /// - 不抛出异常
        /// </summary>
        /// <param name="xid">全局事务ID</param>
        /// <param name="branchId">分支事务ID</param>
        /// <returns>分支状态，失败返回Unknown</returns>
        Task<BranchStatus> GetBranchStatusAsync(string xid, long branchId);

        /// <summary>
        /// 获取TCC事务上下文
        ///
        /// 根据XID从内存缓存中获取TCC事务上下文。
        ///
        /// 执行流程：
        /// 1. 从_transactionContexts字典中查找XID
        /// 2. 如果找到，返回TccTransactionContext
        /// 3. 如果未找到，返回null
        ///
        /// 使用场景：
        /// - 查询事务的分支列表
        /// - 获取事务状态和阶段
        /// - 访问事务元数据（开始时间、超时等）
        ///
        /// 注意事项：
        /// - 返回值可能为null（事务未开始或已完成）
        /// - 事务提交或回滚后上下文会被清理
        /// - 上下文仅存储在内存中（不持久化）
        /// </summary>
        /// <param name="xid">全局事务ID</param>
        /// <returns>TCC事务上下文，未找到返回null</returns>
        TccTransactionContext? GetTransactionContext(string xid);
    }

    /// <summary>
    /// TCC事务管理器默认实现
    ///
    /// ITccTransactionManager接口的默认实现类，负责管理TCC模式全局事务的完整生命周期。
    ///
    /// 职责：
    /// 1. 管理TCC全局事务的开始、提交和回滚
    /// 2. 维护所有活跃事务的上下文（使用ConcurrentDictionary缓存）
    /// 3. 注册和管理TCC分支事务
    /// 4. 协调Try、Confirm、Cancel三个阶段的执行
    /// 5. 向TC上报分支事务状态
    /// 6. 与ITransactionManager协作，处理底层通信
    ///
    /// 工作原理：
    /// ```
    /// 1. Begin阶段：
    ///    - 调用ITransactionManager.BeginAsync()向TC申请全局事务
    ///    - TC分配XID并返回
    ///    - 创建TccTransactionContext并缓存到_transactionContexts
    ///    - 设置状态为Trying，阶段为Try
    ///
    /// 2. Try阶段（业务执行）：
    ///    - TCC服务调用RegisterBranchAsync()注册分支
    ///    - 向TC注册分支事务，获取BranchId
    ///    - 创建TccBranchContext并添加到全局事务上下文
    ///    - 执行业务的Try方法（预留资源）
    ///
    /// 3. Commit阶段（成功路径）：
    ///    - 调用CommitAsync()提交全局事务
    ///    - 遍历所有分支，依次执行ExecuteConfirmAsync()
    ///    - 每个分支调用业务的Confirm方法（确认提交）
    ///    - 调用ITransactionManager.CommitAsync()通知TC
    ///    - 清理事务上下文
    ///
    /// 4. Rollback阶段（失败路径）：
    ///    - 调用RollbackAsync()回滚全局事务
    ///    - 遍历所有分支，依次执行ExecuteCancelAsync()
    ///    - 每个分支调用业务的Cancel方法（释放资源）
    ///    - 调用ITransactionManager.RollbackAsync()通知TC
    ///    - 清理事务上下文
    /// ```
    ///
    /// 数据结构：
    /// - _transactionManager：底层事务管理器（与TC通信）
    /// - _logger：日志记录器
    /// - _transactionContexts：活跃事务上下文缓存（ConcurrentDictionary<XID, TccTransactionContext>）
    ///
    /// 线程安全：
    /// - 类本身注册为Singleton，整个应用共享一个实例
    /// - _transactionContexts使用ConcurrentDictionary，线程安全
    /// - 每个事务有独立的TccTransactionContext
    /// - 事务上下文在提交或回滚后会被清理
    ///
    /// 与AT模式的区别：
    /// - AT模式：自动管理undo_log，二阶段由框架执行
    /// - TCC模式：需要调用业务的Confirm/Cancel方法，二阶段由业务执行
    /// - AT模式：使用AtConnectionProxy拦截SQL
    /// - TCC模式：使用TccServiceProxy拦截服务调用
    ///
    /// 使用示例：
    /// ```csharp
    /// // 在依赖注入中注册
    /// services.AddSingleton<ITccTransactionManager, DefaultTccTransactionManager>();
    ///
    /// // 在业务代码中使用
    /// var result = await _tccTransactionManager.BeginAsync(60000, "place-order");
    /// try
    /// {
    ///     // 注册分支并执行Try
    ///     await _orderService.TryPlaceOrderAsync(order);
    ///     await _inventoryService.TryDeductAsync(product, quantity);
    ///
    ///     // 提交全局事务（执行Confirm）
    ///     await _tccTransactionManager.CommitAsync(result.Xid);
    /// }
    /// catch
    /// {
    ///     // 回滚全局事务（执行Cancel）
    ///     await _tccTransactionManager.RollbackAsync(result.Xid);
    /// }
    /// ```
    ///
    /// 注意事项：
    /// - 注册为Singleton生命周期，整个应用共享
    /// - 事务上下文仅存储在内存中（不持久化）
    /// - 应用重启会丢失所有事务上下文
    /// - Confirm和Cancel必须是幂等的（TC可能重试）
    /// - 事务完成后必须清理上下文（避免内存泄漏）
    /// - 依赖TccServiceRegistry查找TCC服务
    /// </summary>
    public class DefaultTccTransactionManager : ITccTransactionManager
    {
        private readonly ITransactionManager _transactionManager;
        private readonly ILogger<DefaultTccTransactionManager> _logger;
        private readonly ConcurrentDictionary<string, TccTransactionContext> _transactionContexts;

        /// <summary>
        /// 构造函数
        ///
        /// 初始化TCC事务管理器，注入依赖服务。
        ///
        /// 执行流程：
        /// 1. 注入ITransactionManager（底层事务管理器，与TC通信）
        /// 2. 注入ILogger（日志记录器）
        /// 3. 创建ConcurrentDictionary用于缓存事务上下文
        ///
        /// 依赖服务说明：
        /// - ITransactionManager：通用事务管理器
        ///   - 负责与TC通信（BeginAsync、CommitAsync、RollbackAsync）
        ///   - 注册分支事务（RegisterBranchAsync）
        ///   - 上报分支状态（ReportBranchStatusAsync）
        /// - ILogger<DefaultTccTransactionManager>：日志记录器
        ///   - 记录事务生命周期日志
        ///   - 记录分支执行情况
        ///   - 记录异常和错误信息
        ///
        /// 注意事项：
        /// - 通过依赖注入获取所有依赖服务
        /// - _transactionContexts在构造时初始化为空字典
        /// - 类注册为Singleton，构造函数只执行一次
        /// - 所有活跃事务的上下文都存储在_transactionContexts中
        /// </summary>
        /// <param name="transactionManager">通用事务管理器，用于与TC通信</param>
        /// <param name="logger">日志记录器</param>
        public DefaultTccTransactionManager(
            ITransactionManager transactionManager,
            ILogger<DefaultTccTransactionManager> logger)
        {
            _transactionManager = transactionManager;
            _logger = logger;
            _transactionContexts = new ConcurrentDictionary<string, TccTransactionContext>();
        }

        /// <summary>
        /// 开始TCC全局事务（实现）
        ///
        /// ITccTransactionManager.BeginAsync()的具体实现，开启新的TCC全局事务。
        ///
        /// 执行流程：
        /// 1. 记录调试日志，包含超时时间和事务名称
        /// 2. 调用_transactionManager.BeginAsync(timeoutMs, name)：
        ///    - 向TC发送开启事务请求
        ///    - TC分配全局唯一的XID
        ///    - 返回XID给RM
        /// 3. 检查返回的XID是否有效（非空）
        /// 4. 如果XID有效，创建TccTransactionContext事务上下文：
        ///    - 设置Xid为TC返回的XID
        ///    - 设置TransactionName为传入的name
        ///    - 设置Timeout为传入的timeoutMs
        ///    - 设置Status为TccTransactionStatus.Trying
        ///    - 设置Phase为TccTransactionPhase.Try
        ///    - 初始化Branches为空列表
        ///    - 设置StartTime为当前UTC时间
        /// 5. 将事务上下文添加到_transactionContexts缓存：
        ///    - 使用TryAdd确保线程安全
        ///    - 键为XID，值为TccTransactionContext
        /// 6. 记录事务开始成功的日志
        /// 7. 返回BeginResult：
        ///    - Success：XID是否有效
        ///    - Xid：全局事务ID
        /// 8. 如果发生异常，记录错误日志并抛出TransactionException
        ///
        /// 调用时机：
        /// - TCC事务开始时
        /// - 通常由TccTransactionInterceptor或TccTransactionTemplate调用
        /// - 在执行任何Try方法之前调用
        ///
        /// 返回值说明：
        /// - BeginResult.Success为true：事务开始成功
        /// - BeginResult.Success为false：事务开始失败（TC不可用或网络异常）
        /// - BeginResult.Xid：全局事务ID，后续提交和回滚时使用
        ///
        /// 注意事项：
        /// - timeoutMs默认60秒，超时TC会自动回滚
        /// - name用于日志和监控，建议使用有意义的名称
        /// - 开启失败会抛出TransactionException
        /// - 事务上下文存储在内存中，应用重启会丢失
        /// - 必须在finally块中调用CommitAsync或RollbackAsync
        /// </summary>
        /// <param name="timeoutMs">超时时间（毫秒），默认60000ms</param>
        /// <param name="name">事务名称，用于日志和监控</param>
        /// <returns>事务开始结果，包含Success标志和XID</returns>
        /// <exception cref="TransactionException">开启事务失败时抛出</exception>
        public async Task<BeginResult> BeginAsync(int timeoutMs = 60000, string? name = null)
        {
            _logger.LogDebug($"开始TCC事务: Timeout={timeoutMs}, Name={name}");

            try
            {
                // 调用底层事务管理器开始事务
                var xid = await _transactionManager.BeginAsync(timeoutMs, name);

                if (!string.IsNullOrEmpty(xid))
                {
                    // 创建TCC事务上下文
                    var context = new TccTransactionContext
                    {
                        Xid = xid,
                        TransactionName = name,
                        Timeout = timeoutMs,
                        Status = TccTransactionStatus.Trying,
                        Phase = TccTransactionPhase.Try,
                        Branches = new List<TccBranchContext>(),
                        StartTime = DateTime.UtcNow
                    };

                    _transactionContexts.TryAdd(xid, context);

                    _logger.LogDebug($"TCC事务已开始: XID={xid}");
                }
                else
                {
                    _logger.LogError($"开始TCC事务失败");
                }

                return new BeginResult { Success = !string.IsNullOrEmpty(xid), Xid = xid };
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, $"开始TCC事务异常: Timeout={timeoutMs}, Name={name}");
                throw new TransactionException($"开始TCC事务异常: {ex.Message}", ex);
            }
        }

        /// <summary>
        /// 提交TCC全局事务（实现）
        ///
        /// ITccTransactionManager.CommitAsync()的具体实现，执行所有分支的Confirm阶段。
        ///
        /// 执行流程：
        /// 1. 记录调试日志，包含XID
        /// 2. 从_transactionContexts缓存中获取事务上下文：
        ///    - 使用TryGetValue获取TccTransactionContext
        ///    - 如果未找到上下文，记录警告日志
        ///    - 即使没有上下文，也尝试调用底层_transactionManager.CommitAsync()
        ///    - 返回CommitResult（根据底层提交结果）
        /// 3. 如果找到上下文，执行Confirm阶段：
        ///    - 设置context.Status为TccTransactionStatus.Confirming
        ///    - 设置context.Phase为TccTransactionPhase.Confirm
        ///    - 创建confirmResults列表收集每个分支的执行结果
        /// 4. 遍历context.Branches中的所有分支：
        ///    - 对每个分支调用ExecuteConfirmAsync(branch)
        ///    - ExecuteConfirmAsync()会调用业务的Confirm方法
        ///    - 将执行结果添加到confirmResults列表
        ///    - 如果Confirm失败，记录错误日志但继续执行
        ///    - 捕获异常，记录日志并标记该分支失败
        /// 5. 检查是否所有分支都成功Confirm：
        ///    - 使用confirmResults.All(r => r)检查
        ///    - 如果全部成功，设置context.Status为Confirmed
        ///    - 如果有失败，设置context.Status为ConfirmFailed
        /// 6. 调用_transactionManager.CommitAsync(xid)提交底层事务：
        ///    - 通知TC全局事务已提交
        ///    - TC更新全局事务状态
        ///    - TC可能发起异步重试失败的分支
        /// 7. 创建CommitResult返回结果：
        ///    - Success：底层提交成功且所有分支Confirm成功
        ///    - Message：提交结果消息
        /// 8. 记录提交结果日志（成功或失败）
        /// 9. finally块中清理事务上下文：
        ///    - 使用_transactionContexts.TryRemove(xid, out _)移除
        ///    - 确保内存不泄漏
        /// 10. 如果发生异常，记录错误日志并抛出TransactionException
        ///
        /// Confirm阶段说明：
        /// - Confirm确认提交Try阶段预留的资源
        /// - 每个分支调用业务实现的Confirm方法
        /// - Confirm必须是幂等的（TC可能重试）
        /// - Confirm失败不影响其他分支的执行
        /// - TC会异步重试失败的Confirm
        ///
        /// 调用时机：
        /// - Try阶段全部成功后
        /// - 通常由TccTransactionInterceptor或TccTransactionTemplate调用
        /// - 在业务逻辑执行成功后调用
        ///
        /// 返回值说明：
        /// - CommitResult.Success为true：底层提交成功且所有分支Confirm成功
        /// - CommitResult.Success为false：底层提交失败或部分分支Confirm失败
        /// - CommitResult.Message：详细的提交结果消息
        ///
        /// 注意事项：
        /// - 即使部分分支Confirm失败，整体仍可能返回成功（取决于底层提交结果）
        /// - TC会异步重试失败的Confirm分支
        /// - Confirm方法应该快速执行（不应有耗时操作）
        /// - finally块中必须清理事务上下文
        /// - 未找到上下文时仍尝试提交底层事务（容错处理）
        /// </summary>
        /// <param name="xid">全局事务ID</param>
        /// <returns>事务提交结果，包含Success标志和Message</returns>
        /// <exception cref="TransactionException">提交事务异常时抛出</exception>
        public async Task<CommitResult> CommitAsync(string xid)
        {
            _logger.LogDebug($"提交TCC事务: XID={xid}");

            try
            {
                // 获取TCC事务上下文
                if (!_transactionContexts.TryGetValue(xid, out var context))
                {
                    _logger.LogWarning($"未找到TCC事务上下文: XID={xid}");
                    // 即使没有上下文，也尝试提交底层事务
                    var commitSuccess = await _transactionManager.CommitAsync(xid);
                    return new CommitResult { Success = commitSuccess, Message = commitSuccess ? "提交成功" : "提交失败" };
                }

                // 执行Confirm阶段
                context.Status = TccTransactionStatus.Confirming;
                context.Phase = TccTransactionPhase.Confirm;

                var confirmResults = new List<bool>();
                foreach (var branch in context.Branches)
                {
                    try
                    {
                        var confirmResult = await ExecuteConfirmAsync(branch);
                        confirmResults.Add(confirmResult);

                        if (!confirmResult)
                        {
                            _logger.LogError($"TCC分支Confirm失败: XID={xid}, BranchId={branch.BranchId}, ResourceId={branch.ResourceId}");
                        }
                    }
                    catch (Exception ex)
                    {
                        _logger.LogError(ex, $"TCC分支Confirm异常: XID={xid}, BranchId={branch.BranchId}, ResourceId={branch.ResourceId}");
                        confirmResults.Add(false);
                    }
                }

                // 检查是否所有分支都成功Confirm
                var allConfirmed = confirmResults.All(r => r);

                if (allConfirmed)
                {
                    context.Status = TccTransactionStatus.Confirmed;
                    _logger.LogDebug($"所有TCC分支已Confirm: XID={xid}");
                }
                else
                {
                    context.Status = TccTransactionStatus.ConfirmFailed;
                    _logger.LogError($"部分TCC分支Confirm失败: XID={xid}");
                }

                // 提交底层事务
                var success = await _transactionManager.CommitAsync(xid);
                var result = new CommitResult
                {
                    Success = success && allConfirmed,
                    Message = success && allConfirmed ? "TCC事务提交成功" : "TCC事务提交失败"
                };

                if (result.Success)
                {
                    _logger.LogDebug($"TCC事务已提交: XID={xid}");
                }
                else
                {
                    _logger.LogError($"提交TCC事务失败: XID={xid}, Message={result.Message}");
                }

                return result;
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, $"提交TCC事务异常: XID={xid}");
                throw new TransactionException($"提交TCC事务异常: {ex.Message}", ex);
            }
            finally
            {
                // 清理事务上下文
                _transactionContexts.TryRemove(xid, out _);
            }
        }

        /// <summary>
        /// 回滚TCC全局事务（实现）
        ///
        /// ITccTransactionManager.RollbackAsync()的具体实现，执行所有分支的Cancel阶段。
        ///
        /// 执行流程：
        /// 1. 记录调试日志，包含XID
        /// 2. 从_transactionContexts缓存中获取事务上下文：
        ///    - 使用TryGetValue获取TccTransactionContext
        ///    - 如果未找到上下文，记录警告日志
        ///    - 即使没有上下文，也尝试调用底层_transactionManager.RollbackAsync()
        ///    - 返回RollbackResult（根据底层回滚结果）
        /// 3. 如果找到上下文，执行Cancel阶段：
        ///    - 设置context.Status为TccTransactionStatus.Canceling
        ///    - 设置context.Phase为TccTransactionPhase.Cancel
        ///    - 创建cancelResults列表收集每个分支的执行结果
        /// 4. 遍历context.Branches中的所有分支：
        ///    - 对每个分支调用ExecuteCancelAsync(branch)
        ///    - ExecuteCancelAsync()会调用业务的Cancel方法
        ///    - 将执行结果添加到cancelResults列表
        ///    - 如果Cancel失败，记录错误日志但继续执行
        ///    - 捕获异常，记录日志并标记该分支失败
        /// 5. 检查是否所有分支都成功Cancel：
        ///    - 使用cancelResults.All(r => r)检查
        ///    - 如果全部成功，设置context.Status为Canceled
        ///    - 如果有失败，设置context.Status为CancelFailed
        /// 6. 调用_transactionManager.RollbackAsync(xid)回滚底层事务：
        ///    - 通知TC全局事务已回滚
        ///    - TC更新全局事务状态
        ///    - TC可能发起异步重试失败的分支
        /// 7. 创建RollbackResult返回结果：
        ///    - Success：底层回滚成功且所有分支Cancel成功
        ///    - Message：回滚结果消息
        /// 8. 记录回滚结果日志（成功或失败）
        /// 9. finally块中清理事务上下文：
        ///    - 使用_transactionContexts.TryRemove(xid, out _)移除
        ///    - 确保内存不泄漏
        /// 10. 如果发生异常，记录错误日志并抛出TransactionException
        ///
        /// Cancel阶段说明：
        /// - Cancel释放Try阶段预留的资源
        /// - 每个分支调用业务实现的Cancel方法
        /// - Cancel必须是幂等的（TC可能重试）
        /// - Cancel失败不影响其他分支的执行
        /// - TC会异步重试失败的Cancel
        ///
        /// 调用时机：
        /// - Try阶段发生异常时
        /// - 全局事务需要回滚时
        /// - TC超时自动回滚时
        /// - 通常由TccTransactionInterceptor或TccTransactionTemplate调用
        ///
        /// 返回值说明：
        /// - RollbackResult.Success为true：底层回滚成功且所有分支Cancel成功
        /// - RollbackResult.Success为false：底层回滚失败或部分分支Cancel失败
        /// - RollbackResult.Message：详细的回滚结果消息
        ///
        /// 注意事项：
        /// - 即使部分分支Cancel失败，整体仍可能返回成功（取决于底层回滚结果）
        /// - TC会异步重试失败的Cancel分支
        /// - Cancel方法应该快速执行（不应有耗时操作）
        /// - finally块中必须清理事务上下文
        /// - 未找到上下文时仍尝试回滚底层事务（容错处理）
        /// - Cancel失败可能导致资源泄漏（需要人工介入或定时清理）
        /// </summary>
        /// <param name="xid">全局事务ID</param>
        /// <returns>事务回滚结果，包含Success标志和Message</returns>
        /// <exception cref="TransactionException">回滚事务异常时抛出</exception>
        public async Task<RollbackResult> RollbackAsync(string xid)
        {
            _logger.LogDebug($"回滚TCC事务: XID={xid}");

            try
            {
                // 获取TCC事务上下文
                if (!_transactionContexts.TryGetValue(xid, out var context))
                {
                    _logger.LogWarning($"未找到TCC事务上下文: XID={xid}");
                    // 即使没有上下文，也尝试回滚底层事务
                    var rollbackSuccess = await _transactionManager.RollbackAsync(xid);
                    return new RollbackResult { Success = rollbackSuccess, Message = rollbackSuccess ? "回滚成功" : "回滚失败" };
                }

                // 执行Cancel阶段
                context.Status = TccTransactionStatus.Canceling;
                context.Phase = TccTransactionPhase.Cancel;

                var cancelResults = new List<bool>();
                foreach (var branch in context.Branches)
                {
                    try
                    {
                        var cancelResult = await ExecuteCancelAsync(branch);
                        cancelResults.Add(cancelResult);

                        if (!cancelResult)
                        {
                            _logger.LogError($"TCC分支Cancel失败: XID={xid}, BranchId={branch.BranchId}, ResourceId={branch.ResourceId}");
                        }
                    }
                    catch (Exception ex)
                    {
                        _logger.LogError(ex, $"TCC分支Cancel异常: XID={xid}, BranchId={branch.BranchId}, ResourceId={branch.ResourceId}");
                        cancelResults.Add(false);
                    }
                }

                // 检查是否所有分支都成功Cancel
                var allCanceled = cancelResults.All(r => r);

                if (allCanceled)
                {
                    context.Status = TccTransactionStatus.Canceled;
                    _logger.LogDebug($"所有TCC分支已Cancel: XID={xid}");
                }
                else
                {
                    context.Status = TccTransactionStatus.CancelFailed;
                    _logger.LogError($"部分TCC分支Cancel失败: XID={xid}");
                }

                // 回滚底层事务
                var success = await _transactionManager.RollbackAsync(xid);
                var result = new RollbackResult
                {
                    Success = success && allCanceled,
                    Message = success && allCanceled ? "TCC事务回滚成功" : "TCC事务回滚失败"
                };

                if (result.Success)
                {
                    _logger.LogDebug($"TCC事务已回滚: XID={xid}");
                }
                else
                {
                    _logger.LogError($"回滚TCC事务失败: XID={xid}, Message={result.Message}");
                }

                return result;
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, $"回滚TCC事务异常: XID={xid}");
                throw new TransactionException($"回滚TCC事务异常: {ex.Message}", ex);
            }
            finally
            {
                // 清理事务上下文
                _transactionContexts.TryRemove(xid, out _);
            }
        }

        /// <summary>
        /// 注册TCC分支事务（实现）
        ///
        /// ITccTransactionManager.RegisterBranchAsync()的具体实现，向TC注册TCC分支事务。
        ///
        /// 执行流程：
        /// 1. 记录调试日志，包含XID和ResourceId
        /// 2. 从_transactionContexts缓存中获取事务上下文：
        ///    - 使用TryGetValue获取TccTransactionContext
        ///    - 如果未找到，抛出TransactionException
        /// 3. 创建BranchRegisterRequest分支注册请求：
        ///    - Xid：全局事务ID
        ///    - BranchType：设置为TransactionConstants.BRANCH_TYPE_TCC
        ///    - ResourceId：资源标识符（通常是服务名称）
        ///    - LockKey：空字符串（TCC模式不需要全局锁）
        ///    - ApplicationData：设置为actionContext（JSON格式的TccActionContext）
        /// 4. 调用_transactionManager.RegisterBranchAsync()向TC注册分支：
        ///    - TC分配BranchId并返回
        ///    - TC记录分支信息到存储
        /// 5. 创建TccBranchContext分支上下文：
        ///    - Xid：全局事务ID
        ///    - BranchId：TC返回的分支ID
        ///    - ResourceId：资源标识符
        ///    - ActionContext：动作上下文（包含服务名、方法名、参数等）
        ///    - Status：设置为TccBranchStatus.Registered
        ///    - Phase：设置为TccTransactionPhase.Try
        /// 6. 将分支上下文添加到全局事务上下文的Branches列表：
        ///    - context.Branches.Add(branchContext)
        /// 7. 记录分支注册成功的日志
        /// 8. 返回BranchRegisterResponse：
        ///    - BranchId：TC分配的分支ID
        ///    - ResultCode：ResultCode.Success
        /// 9. 如果发生异常，记录错误日志并抛出TransactionException
        ///
        /// actionContext说明：
        /// - JSON格式的TccActionContext对象
        /// - 包含：ServiceName（服务名）、MethodName（方法名）、Parameters（参数）
        /// - 用于Confirm和Cancel阶段定位和调用业务方法
        /// - 示例：{"ServiceName":"OrderService","MethodName":"PlaceOrder","Parameters":{...}}
        ///
        /// 调用时机：
        /// - Try阶段执行前
        /// - 通常由TccServiceProxy自动调用
        /// - 在执行业务Try方法之前注册分支
        ///
        /// 返回值说明：
        /// - BranchRegisterResponse.BranchId：TC分配的分支ID
        /// - BranchRegisterResponse.ResultCode：注册结果（Success或失败）
        ///
        /// 注意事项：
        /// - 注册失败会抛出TransactionException
        /// - actionContext必须包含完整的方法调用信息
        /// - resourceId通常是服务名称（如"OrderService"）
        /// - TCC模式的LockKey为空（不需要全局锁）
        /// - 分支注册顺序会影响Confirm/Cancel的执行顺序
        /// </summary>
        /// <param name="xid">全局事务ID</param>
        /// <param name="resourceId">资源ID，通常是TCC服务名称</param>
        /// <param name="actionContext">动作上下文，JSON格式的TccActionContext</param>
        /// <returns>分支注册结果，包含BranchId和ResultCode</returns>
        /// <exception cref="TransactionException">注册分支失败或未找到事务上下文时抛出</exception>
        public async Task<BranchRegisterResponse> RegisterBranchAsync(string xid, string resourceId, string actionContext)
        {
            _logger.LogDebug($"注册TCC分支事务: XID={xid}, ResourceId={resourceId}");

            try
            {
                // 获取TCC事务上下文
                if (!_transactionContexts.TryGetValue(xid, out var context))
                {
                    throw new TransactionException($"未找到TCC事务上下文: XID={xid}");
                }

                // 创建分支注册请求
                var request = new BranchRegisterRequest
                {
                    Xid = xid,
                    BranchType = TransactionConstants.BRANCH_TYPE_TCC,
                    ResourceId = resourceId,
                    LockKey = "",
                    ApplicationData = actionContext
                };

                // 发送注册请求
                var branchId = await _transactionManager.RegisterBranchAsync(xid, resourceId, "");

                // 添加TCC分支上下文
                var branchContext = new TccBranchContext
                {
                    Xid = xid,
                    BranchId = branchId,
                    ResourceId = resourceId,
                    ActionContext = actionContext,
                    Status = TccBranchStatus.Registered,
                    Phase = TccTransactionPhase.Try
                };

                context.Branches.Add(branchContext);

                _logger.LogDebug($"TCC分支事务注册成功: XID={xid}, BranchId={branchId}, ResourceId={resourceId}");

                // 返回成功的注册响应
                return new BranchRegisterResponse
                {
                    BranchId = branchId,
                    ResultCode = ResultCode.Success
                };
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, $"注册TCC分支事务异常: XID={xid}, ResourceId={resourceId}");
                throw new TransactionException($"注册TCC分支事务异常: {ex.Message}", ex);
            }
        }

        /// <summary>
        /// 上报TCC分支事务状态（实现）
        ///
        /// ITccTransactionManager.ReportBranchStatusAsync()的具体实现，向TC上报分支事务状态。
        ///
        /// 执行流程：
        /// 1. 记录调试日志，包含XID、BranchId和Status
        /// 2. 创建BranchReportRequest状态上报请求：
        ///    - Xid：全局事务ID
        ///    - BranchId：分支事务ID
        ///    - BranchType：设置为TransactionConstants.BRANCH_TYPE_TCC
        ///    - Status：分支状态（BranchStatus枚举）
        ///    - ApplicationData：空对象的JSON序列化（TCC不需要额外数据）
        /// 3. 调用_transactionManager.ReportBranchStatusAsync()向TC发送状态：
        ///    - TC更新分支状态到存储
        ///    - TC可能根据状态触发后续操作
        /// 4. 记录上报成功的日志
        /// 5. 返回BranchReportResponse：
        ///    - ResultCode：ResultCode.Success
        /// 6. 如果发生异常，记录错误日志并抛出TransactionException
        ///
        /// 状态说明：
        /// - PhaseOneDone：Try阶段完成
        /// - PhaseTwoCommitted：Confirm阶段完成
        /// - PhaseTwoRollbacked：Cancel阶段完成
        /// - PhaseTwoCommitFailedRetryable：Confirm失败，可重试
        /// - PhaseTwoRollbackFailedRetryable：Cancel失败，可重试
        ///
        /// 调用时机：
        /// - Try阶段完成后
        /// - Confirm阶段完成后
        /// - Cancel阶段完成后
        /// - 分支状态变更时
        ///
        /// 注意事项：
        /// - 上报失败会抛出TransactionException
        /// - TC根据状态决定后续操作（重试、清理等）
        /// - ApplicationData在TCC模式下通常为空
        /// </summary>
        /// <param name="xid">全局事务ID</param>
        /// <param name="branchId">分支事务ID</param>
        /// <param name="status">分支状态</param>
        /// <returns>状态上报结果</returns>
        /// <exception cref="TransactionException">上报状态失败时抛出</exception>
        public async Task<BranchReportResponse> ReportBranchStatusAsync(string xid, long branchId, BranchStatus status)
        {
            _logger.LogDebug($"上报TCC分支事务状态: XID={xid}, BranchId={branchId}, Status={status}");

            try
            {
                // 创建状态上报请求
                var request = new BranchReportRequest
                {
                    Xid = xid,
                    BranchId = branchId,
                    BranchType = TransactionConstants.BRANCH_TYPE_TCC,
                    Status = status,
                    ApplicationData = JsonSerializer.Serialize(new { })
                };

                // 发送状态上报请求
                await _transactionManager.ReportBranchStatusAsync(xid, branchId, status);

                _logger.LogDebug($"TCC分支事务状态上报成功: XID={xid}, BranchId={branchId}");

                // 返回成功响应
                return new BranchReportResponse
                {
                    ResultCode = ResultCode.Success
                };
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, $"上报TCC分支事务状态异常: XID={xid}, BranchId={branchId}");
                throw new TransactionException($"上报TCC分支事务状态异常: {ex.Message}", ex);
            }
        }

        /// <summary>
        /// 获取TCC分支事务状态（实现）
        ///
        /// ITccTransactionManager.GetBranchStatusAsync()的具体实现，从TC查询分支事务状态。
        ///
        /// 执行流程：
        /// 1. 记录调试日志，包含XID和BranchId
        /// 2. 创建BranchStatusRequest状态查询请求：
        ///    - Xid：全局事务ID
        ///    - BranchId：分支事务ID
        ///    - BranchType：设置为TransactionConstants.BRANCH_TYPE_TCC
        /// 3. 调用_transactionManager.GetBranchStatusAsync()从TC查询状态：
        ///    - TC从存储中查询分支状态
        ///    - 返回BranchStatus枚举值
        /// 4. 记录查询成功的日志，包含返回的Status
        /// 5. 返回分支状态（BranchStatus）
        /// 6. 如果发生异常：
        ///    - 记录错误日志
        ///    - 返回BranchStatus.Unknown（不抛出异常）
        ///
        /// 使用场景：
        /// - 监控分支事务状态
        /// - 诊断事务执行情况
        /// - 重试前检查状态
        /// - 异常恢复时查询状态
        ///
        /// 返回值说明：
        /// - BranchStatus枚举值：表示分支当前状态
        /// - BranchStatus.Unknown：查询失败时返回
        ///
        /// 注意事项：
        /// - 查询失败返回Unknown而不抛出异常
        /// - 状态可能不是实时的（取决于TC的状态同步）
        /// - 可用于实现状态轮询
        /// </summary>
        /// <param name="xid">全局事务ID</param>
        /// <param name="branchId">分支事务ID</param>
        /// <returns>分支状态，失败返回Unknown</returns>
        public async Task<BranchStatus> GetBranchStatusAsync(string xid, long branchId)
        {
            _logger.LogDebug($"获取TCC分支事务状态: XID={xid}, BranchId={branchId}");

            try
            {
                // 创建状态查询请求
                var request = new BranchStatusRequest
                {
                    Xid = xid,
                    BranchId = branchId,
                    BranchType = TransactionConstants.BRANCH_TYPE_TCC
                };

                // 发送状态查询请求
                var status = await _transactionManager.GetBranchStatusAsync(xid, branchId);

                _logger.LogDebug($"获取TCC分支事务状态成功: XID={xid}, BranchId={branchId}, Status={status}");
                return status;
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, $"获取TCC分支事务状态异常: XID={xid}, BranchId={branchId}");
                return BranchStatus.Unknown;
            }
        }

        /// <summary>
        /// 执行TCC分支Confirm（私有方法）
        ///
        /// CommitAsync()内部调用此方法执行单个分支的Confirm阶段。
        ///
        /// 执行流程：
        /// 1. 记录调试日志，包含XID、BranchId和ResourceId
        /// 2. 反序列化branch.ActionContext为TccActionContext对象：
        ///    - 使用JsonSerializer.Deserialize解析JSON
        ///    - 获取ServiceName、MethodName、Parameters等信息
        /// 3. 从TccServiceRegistry获取TCC服务实例：
        ///    - 使用actionContext.ServiceName作为键
        ///    - TccServiceRegistry是全局服务注册表
        /// 4. 检查服务是否存在：
        ///    - 如果为null，记录错误日志并返回false
        ///    - 说明服务未注册或已卸载
        /// 5. 调用tccService.ConfirmAsync(actionContext)执行Confirm方法：
        ///    - 传入actionContext包含方法调用所需的所有信息
        ///    - 业务实现的Confirm方法被调用
        ///    - 返回执行结果（bool）
        /// 6. 根据执行结果更新分支状态：
        ///    - 成功：设置branch.Status为TccBranchStatus.Confirmed
        ///    - 失败：设置branch.Status为TccBranchStatus.ConfirmFailed
        /// 7. 记录执行结果日志（成功或失败）
        /// 8. 返回执行结果
        /// 9. 如果发生异常：
        ///    - 记录错误日志
        ///    - 设置branch.Status为ConfirmFailed
        ///    - 返回false
        ///
        /// Confirm方法要求：
        /// - 必须是幂等的（可重复执行，结果相同）
        /// - 应该快速执行（不应有长时间阻塞）
        /// - 确认提交Try阶段预留的资源
        /// - 释放业务锁定
        ///
        /// 调用时机：
        /// - CommitAsync()遍历所有分支时调用
        /// - 在Try阶段全部成功后
        /// - TC发起全局提交时
        ///
        /// 注意事项：
        /// - 方法是私有的，只能被CommitAsync()调用
        /// - 异常不向上抛出，通过返回值表示失败
        /// - TC会异步重试失败的Confirm
        /// - 服务未找到是严重错误（配置问题）
        /// </summary>
        /// <param name="branch">TCC分支上下文</param>
        /// <returns>Confirm执行结果，成功返回true，失败返回false</returns>
        private async Task<bool> ExecuteConfirmAsync(TccBranchContext branch)
        {
            _logger.LogDebug($"执行TCC分支Confirm: XID={branch.Xid}, BranchId={branch.BranchId}, ResourceId={branch.ResourceId}");

            try
            {
                // 解析动作上下文
                var actionContext = JsonSerializer.Deserialize<TccActionContext>(branch.ActionContext);
                
                // 获取TCC服务
                var tccService = TccServiceRegistry.GetService(actionContext.ServiceName);
                
                if (tccService == null)
                {
                    _logger.LogError($"未找到TCC服务: ServiceName={actionContext.ServiceName}");
                    return false;
                }
                
                // 执行Confirm方法
                var confirmResult = await tccService.ConfirmAsync(actionContext);
                
                if (confirmResult)
                {
                    branch.Status = TccBranchStatus.Confirmed;
                    _logger.LogDebug($"TCC分支Confirm成功: XID={branch.Xid}, BranchId={branch.BranchId}");
                }
                else
                {
                    branch.Status = TccBranchStatus.ConfirmFailed;
                    _logger.LogError($"TCC分支Confirm失败: XID={branch.Xid}, BranchId={branch.BranchId}");
                }
                
                return confirmResult;
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, $"执行TCC分支Confirm异常: XID={branch.Xid}, BranchId={branch.BranchId}");
                branch.Status = TccBranchStatus.ConfirmFailed;
                return false;
            }
        }

        /// <summary>
        /// 执行TCC分支Cancel（私有方法）
        ///
        /// RollbackAsync()内部调用此方法执行单个分支的Cancel阶段。
        ///
        /// 执行流程：
        /// 1. 记录调试日志，包含XID、BranchId和ResourceId
        /// 2. 反序列化branch.ActionContext为TccActionContext对象：
        ///    - 使用JsonSerializer.Deserialize解析JSON
        ///    - 获取ServiceName、MethodName、Parameters等信息
        /// 3. 从TccServiceRegistry获取TCC服务实例：
        ///    - 使用actionContext.ServiceName作为键
        ///    - TccServiceRegistry是全局服务注册表
        /// 4. 检查服务是否存在：
        ///    - 如果为null，记录错误日志并返回false
        ///    - 说明服务未注册或已卸载
        /// 5. 调用tccService.CancelAsync(actionContext)执行Cancel方法：
        ///    - 传入actionContext包含方法调用所需的所有信息
        ///    - 业务实现的Cancel方法被调用
        ///    - 返回执行结果（bool）
        /// 6. 根据执行结果更新分支状态：
        ///    - 成功：设置branch.Status为TccBranchStatus.Canceled
        ///    - 失败：设置branch.Status为TccBranchStatus.CancelFailed
        /// 7. 记录执行结果日志（成功或失败）
        /// 8. 返回执行结果
        /// 9. 如果发生异常：
        ///    - 记录错误日志
        ///    - 设置branch.Status为CancelFailed
        ///    - 返回false
        ///
        /// Cancel方法要求：
        /// - 必须是幂等的（可重复执行，结果相同）
        /// - 应该快速执行（不应有长时间阻塞）
        /// - 释放Try阶段预留的资源
        /// - 回滚到Try之前的状态
        ///
        /// 调用时机：
        /// - RollbackAsync()遍历所有分支时调用
        /// - Try阶段发生异常时
        /// - TC发起全局回滚时
        /// - TC超时自动回滚时
        ///
        /// 注意事项：
        /// - 方法是私有的，只能被RollbackAsync()调用
        /// - 异常不向上抛出，通过返回值表示失败
        /// - TC会异步重试失败的Cancel
        /// - 服务未找到是严重错误（配置问题）
        /// - Cancel失败可能导致资源泄漏
        /// </summary>
        /// <param name="branch">TCC分支上下文</param>
        /// <returns>Cancel执行结果，成功返回true，失败返回false</returns>
        private async Task<bool> ExecuteCancelAsync(TccBranchContext branch)
        {
            _logger.LogDebug($"执行TCC分支Cancel: XID={branch.Xid}, BranchId={branch.BranchId}, ResourceId={branch.ResourceId}");

            try
            {
                // 解析动作上下文
                var actionContext = JsonSerializer.Deserialize<TccActionContext>(branch.ActionContext);

                // 获取TCC服务
                var tccService = TccServiceRegistry.GetService(actionContext.ServiceName);

                if (tccService == null)
                {
                    _logger.LogError($"未找到TCC服务: ServiceName={actionContext.ServiceName}");
                    return false;
                }

                // 执行Cancel方法
                var cancelResult = await tccService.CancelAsync(actionContext);

                if (cancelResult)
                {
                    branch.Status = TccBranchStatus.Canceled;
                    _logger.LogDebug($"TCC分支Cancel成功: XID={branch.Xid}, BranchId={branch.BranchId}");
                }
                else
                {
                    branch.Status = TccBranchStatus.CancelFailed;
                    _logger.LogError($"TCC分支Cancel失败: XID={branch.Xid}, BranchId={branch.BranchId}");
                }

                return cancelResult;
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, $"执行TCC分支Cancel异常: XID={branch.Xid}, BranchId={branch.BranchId}");
                branch.Status = TccBranchStatus.CancelFailed;
                return false;
            }
        }

        /// <summary>
        /// 注册TCC分支事务（简化版本）
        ///
        /// RegisterBranchAsync()的简化版本，直接返回BranchId而非完整响应对象。
        ///
        /// 执行流程：
        /// 1. 调用RegisterBranchAsync(xid, resourceId, actionContext)
        /// 2. 获取返回的BranchRegisterResponse对象
        /// 3. 提取response.BranchId
        /// 4. 如果response为null，返回0
        /// 5. 否则返回BranchId
        ///
        /// 使用场景：
        /// - 只需要BranchId，不关心完整响应时
        /// - 简化业务代码调用
        /// - 需要快速获取BranchId
        ///
        /// 注意事项：
        /// - 注册失败返回0而非抛出异常（与RegisterBranchAsync不同）
        /// - 建议使用RegisterBranchAsync获取完整结果（包含错误信息）
        /// - 0可能表示注册失败，需要检查
        /// </summary>
        /// <param name="xid">全局事务ID</param>
        /// <param name="resourceId">资源ID</param>
        /// <param name="actionContext">动作上下文</param>
        /// <returns>分支事务ID，失败返回0</returns>
        public async Task<long> BranchRegisterAsync(string xid, string resourceId, string actionContext)
        {
            var response = await RegisterBranchAsync(xid, resourceId, actionContext);
            return response?.BranchId ?? 0;
        }

        /// <summary>
        /// 上报TCC分支事务状态（简化版本）
        ///
        /// ReportBranchStatusAsync()的简化版本，使用TccBranchStatus而非BranchStatus。
        ///
        /// 执行流程：
        /// 1. 将TccBranchStatus映射为BranchStatus：
        ///    - Registered → Registered
        ///    - Trying → PhaseOneDone
        ///    - Confirmed → PhaseTwoCommitted
        ///    - Canceled → PhaseTwoRollbacked
        ///    - ConfirmFailed → PhaseTwoCommitFailedRetryable
        ///    - CancelFailed → PhaseTwoRollbackFailedRetryable
        ///    - 其他 → Unknown
        /// 2. 调用ReportBranchStatusAsync(xid, branchId, branchStatus)
        /// 3. 检查response.ResultCode是否为Success
        /// 4. 返回布尔值（成功true，失败false）
        ///
        /// 状态映射说明：
        /// - TccBranchStatus是TCC特定的状态枚举
        /// - BranchStatus是通用的分支状态枚举
        /// - 此方法负责两者之间的转换
        ///
        /// 使用场景：
        /// - 业务代码使用TCC特定的状态枚举时
        /// - 不想手动进行状态映射时
        /// - 只需要成功/失败结果时
        ///
        /// 注意事项：
        /// - 上报失败返回false而非抛出异常
        /// - 使用TCC特定的状态枚举（TccBranchStatus）
        /// - 内部调用ReportBranchStatusAsync完成实际上报
        /// </summary>
        /// <param name="xid">全局事务ID</param>
        /// <param name="branchId">分支事务ID</param>
        /// <param name="status">TCC分支状态</param>
        /// <returns>上报成功返回true，失败返回false</returns>
        public async Task<bool> BranchReportAsync(string xid, long branchId, TccBranchStatus status)
        {
            var branchStatus = status switch
            {
                TccBranchStatus.Registered => BranchStatus.Registered,
                TccBranchStatus.Trying => BranchStatus.PhaseOneDone,
                TccBranchStatus.Confirmed => BranchStatus.PhaseTwoCommitted,
                TccBranchStatus.Canceled => BranchStatus.PhaseTwoRollbacked,
                TccBranchStatus.ConfirmFailed => BranchStatus.PhaseTwoCommitFailedRetryable,
                TccBranchStatus.CancelFailed => BranchStatus.PhaseTwoRollbackFailedRetryable,
                _ => BranchStatus.Unknown
            };

            var response = await ReportBranchStatusAsync(xid, branchId, branchStatus);
            return response?.ResultCode == ResultCode.Success;
        }

        /// <summary>
        /// 获取TCC事务上下文（实现）
        ///
        /// ITccTransactionManager.GetTransactionContext()的具体实现，从内存缓存中获取事务上下文。
        ///
        /// 执行流程：
        /// 1. 使用_transactionContexts.TryGetValue(xid, out var context)查找
        /// 2. 如果找到，返回TccTransactionContext对象
        /// 3. 如果未找到，返回null
        ///
        /// 使用场景：
        /// - 查询事务的分支列表
        /// - 获取事务状态和阶段
        /// - 访问事务元数据（开始时间、超时等）
        /// - 监控和诊断事务执行情况
        ///
        /// 返回值说明：
        /// - TccTransactionContext对象：包含事务的完整上下文信息
        /// - null：事务未开始或已完成（提交/回滚后会清理）
        ///
        /// 注意事项：
        /// - 返回值可能为null（事务未开始或已完成）
        /// - 事务提交或回滚后上下文会被清理
        /// - 上下文仅存储在内存中（不持久化）
        /// - 应用重启后所有上下文丢失
        /// - 线程安全（使用ConcurrentDictionary）
        /// </summary>
        /// <param name="xid">全局事务ID</param>
        /// <returns>TCC事务上下文，未找到返回null</returns>
        public TccTransactionContext? GetTransactionContext(string xid)
        {
            _transactionContexts.TryGetValue(xid, out var context);
            return context;
        }
    }
}